package com.xjlsoft.weather.util;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletResponse;

import org.apache.poi.ss.formula.functions.T;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.xjlsoft.weather.common.util.DataUtil;
import com.xjlsoft.weather.common.util.DateUtil;
import com.xjlsoft.weather.common.util.FileUtil;
import com.xjlsoft.weather.common.util.HttpClientUtil;
import com.xjlsoft.weather.dto.AerosolDataResponseJson;
import com.xjlsoft.weather.dto.GroundOtherResponseJson;
import com.xjlsoft.weather.dto.GroundPreResponseJson;
import com.xjlsoft.weather.dto.GroundResponseJson;
import com.xjlsoft.weather.dto.GroundTemResponseJson;
import com.xjlsoft.weather.dto.HighDataResponseJson;
import com.xjlsoft.weather.dto.RadiationMinResponseJson;
import com.xjlsoft.weather.dto.RadiationResponseJson;
import com.xjlsoft.weather.entity.GroundDataExcelDto;
import com.xjlsoft.weather.entity.GroundPreJson;
import com.xjlsoft.weather.entity.QueryLog;
import com.xjlsoft.weather.entity.RadiationMinExcelDto;
import com.xjlsoft.weather.entity.RadiationMinJson;
import com.xjlsoft.weather.entity.RequestApi;
import com.xjlsoft.weather.enums.RequestApiCodeEnum;
import com.xjlsoft.weather.enums.RequestApiEnum;
import com.xjlsoft.weather.enums.ResultCodeEnum;
import com.xjlsoft.weather.exception.WeatherException;


/**
 * 
 * 发送post请求 处理数据
 * */
public class WeatherDataUtil {
	
	
	/**
	 * 针对RequestApiCodeEnum
	 * 例如
	 * 根据 枚举的value  拿到messge
	 * 
	 * @return  没有对应值 则返回  发送失败原因未在枚举中定义
	 * */
	public static String getRequestApiCodeEnumMessageByValue(String value){
		String str="";
		RequestApiCodeEnum mre=RequestApiCodeEnum.valueof(value);
		if(mre!=null){
			str=mre.getMessage();
		}else{
			return RequestApiCodeEnum.ERRORFU10002.getMessage();
		}
		
		return str;
	}
	
	
	/**
	 * @param result  需要保存的结果值
	 * @param file   文件路径   前缀+日期父目录+文件名称.txt
	 * 
	 * */
	public static void saveResultTxtFile(String result,File file) throws IOException{
		
		
		if(!file.getParentFile().exists()){
			file.getParentFile().mkdirs();
		}
		
		OutputStream output=new FileOutputStream(file);
		String restr=result;
		byte data []=restr.getBytes();
		
		//内容输出
		output.write(data);
		output.close();
	}
	
	
	/**
	 * 传入 Timestamp的时间   返回 查询字符串时间
	 * */
	public static String getTimerangeStr(Timestamp  startTime,Timestamp endTime){
		Date start=new Date(startTime.getTime());
		Date end=new Date(endTime.getTime());
		String str1=DateUtil.DateToString(start, "yyyyMMddHHmmss");
		String str2=DateUtil.DateToString(end, "yyyyMMddHHmmss");
		String result="["+str1+","+str2+"]";
		return result;
		
	}
	
	/**
	 * 传入 Date的时间   返回 查询字符串时间
	 * */
	public static String getTimerangeStr(Date  startTime,Date endTime){
		String str1=DateUtil.DateToString(startTime, "yyyyMMddHHmmss");
		String str2=DateUtil.DateToString(endTime, "yyyyMMddHHmmss");
		String result="["+str1+","+str2+"]";
		return result;
		
	}
	
	/**
	 * 传入 Timestamp的时间   
	 * 返回字符串  yyyyMMddHHmmss
	 * */
	public static String getTimestampStr(Timestamp  time){
		Date start=new Date(time.getTime());
		String str1=DateUtil.DateToString(start, "yyyyMMddHHmmss");
		return str1;
		
	}
	
	
	/**
	 * 
	 * @param 年 月 日 时 的字符串 表示
	 * <br> min传入null时 返回   年月日时0分0秒
	 * <br> min不为null时  返回  年月日时分0秒
	 * <br>
	 * 数据格式：yyyyMMddHHmmss
	 * 
	 * */
	public static Timestamp getTimestamp(String year,String mon,String day,String hour,String min){
		
		
		String monstr=mon;
		String daystr=day;
		String hourstr=hour;
		String minstr=min;
		
	    int monInt=mon.length();
	    int dayInt=day.length();
	    int hourInt=hour.length();
	    
	    
	    if(monInt != 2){
	    	monstr="0"+mon;
	    }
	    if(dayInt !=2){
	    	daystr="0"+daystr;
	    }
	    if(hourInt != 2){
	    	hourstr="0"+hourstr;
	    }
	    
	    String dateStr=year+monstr+daystr+hourstr;
	    
	    if(minstr ==null){
	    	dateStr=year+monstr+daystr+hourstr+"0000";
	    }else{
	    	int minInt=min.length();
	    	if(minInt != 2){
	    		minstr="0"+minstr;
		    }
	    	dateStr=year+monstr+daystr+hourstr+minstr+"00";
	    }
	    
	    
	    
	    SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMddHHmmss");
	    Date date;
		try {
			date = fmt.parse(dateStr);
			Timestamp newTimestamp=new Timestamp(date.getTime());
			return newTimestamp;
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return null;
	}
	
	
	
	
	/**
	 * 返回 日期（yyyyMMdd）+文件名称+.txt
	 * 
	 * 
	 *     文件名称格式为     querylogid-查询日期开始-查询日期结束.txt
	 * 
	 * */
	public static String getFilePath(QueryLog querylog){
		
		//已月份 间隔作为目录   202001-2020
		String parentDir=querylog.getTimerangeStartStr().substring(0,6)+"-"+querylog.getTimerangeEndStr().substring(0,6);
		
		//DataUtil.getCurrentDate()
		String fileName=parentDir+File.separatorChar+querylog.getQuery_log_id()+"-"+querylog.getTimerangeStartStr()+"-"+querylog.getTimerangeEndStr()+".txt";
		return fileName;
	}
	
	/**
	 * 返回高空数据的的文件路径
	 * 返回 日期（yyyyMMdd）+文件名称+.txt
	 * 
	 * 
	 *     文件名称格式为     querylogid-查询日期.txt
	 * 
	 * */
	public static String getFilePathByHighData(QueryLog querylog){
		
		String parentDir=querylog.getTimesStr().substring(0,6);
		String fileName=parentDir+File.separatorChar+querylog.getQuery_log_id()+"-"+querylog.getTimesStr()+".txt";
		return fileName;
	}
	
	
	
	/**
	 * 
	 * 比较年月日 是否相等
	 * */
	public static boolean sameDate(Date d1, Date d2){
		SimpleDateFormat fmt = new SimpleDateFormat("yyyyMMdd");
		//fmt.setTimeZone(new TimeZone()); // 如果需要设置时间区域，可以在这里设置
		return fmt.format(d1).equals(fmt.format(d2));
	}
	
	/**
	 * 请求 地面数据 、辐射数据 、气溶胶数 、地面资料-中国地面分钟降水资料
	 *  
	 *  都可按 时间范围查询
	 * 
	 * @param RequestApi  提供 请求url 等其他固定参数
	 * @param QueryLog  提供  请求条件参数
	 * 
	 * */
	public static String requestThereDataApi(RequestApi requestapi,QueryLog querylog){
		String result=new String();
		
		Map<String,String> maps=new HashMap<String,String>();
		maps.put("userId",requestapi.getUser_id());
		maps.put("pwd", requestapi.getPwd());
		maps.put("dataFormat", requestapi.getData_format());
		maps.put("interfaceId", requestapi.getInterface_id());
		maps.put("dataCode",requestapi.getData_code());
		maps.put("timeRange",querylog.getTimeRangeStr());
		maps.put("staIds", requestapi.getSta_ids());
		maps.put("elements", requestapi.getElements());
		//maps.put("limitCnt", String.valueOf(requestapi.getLimitCnt()));  返回全部数据
		String httpUrl=requestapi.getUrl_pix();
		try {
			result = HttpClientUtil.getInstance().sendHttpPost(httpUrl, maps);
		} catch (Exception e) {
			e.printStackTrace();
		}
	    return result;
	}
	
	
	/**
	 * 请求 地面数据 、辐射数据 、气溶胶数 
	 *  
	 *  时间范围查询 探查是否存在数据 根据返回码 code确认
	 * 
	 * @param RequestApi  提供 请求url 等其他固定参数
	 * @param QueryLog  提供  请求条件参数
	 * 
	 * */
	public static String getThereRequestOneData(RequestApi requestapi,QueryLog querylog){
		String result=new String();
		
		Map<String,String> maps=new HashMap<String,String>();
		maps.put("userId",requestapi.getUser_id());
		maps.put("pwd", requestapi.getPwd());
		maps.put("dataFormat", requestapi.getData_format());
		maps.put("interfaceId", requestapi.getInterface_id());
		maps.put("dataCode",requestapi.getData_code());
		maps.put("timeRange",querylog.getTimeRangeStr());
		maps.put("staIds", requestapi.getSta_ids());
		
		List<String> list=WeatherDataUtil.strToArrayList(requestapi.getElements());
		maps.put("elements", list.get(0));  //至查询一个元素
		maps.put("limitCnt","1"); // 至返回一条数据即可
		String httpUrl=requestapi.getUrl_pix();
		try {
			result = HttpClientUtil.getInstance().sendHttpPost(httpUrl, maps);
		} catch (Exception e) {
			e.printStackTrace();
		}
	    return result;
	}
	/**
	 * 
	 * 调用接口 工具类
	 * 
	 * 请求 高空定时值数据
	 *  
	 *  都可按 时间范围查询
	 * 
	 * @param RequestApi  提供 请求url 等 其他固定参数
	 * @param QueryLog  提供  请求条件参数
	 * 
	 * */
	public static String getHighDataApiOneData(RequestApi requestapi,QueryLog querylog){
		String result=new String();
		
		Map<String,String> maps=new HashMap<String,String>();
		maps.put("userId",requestapi.getUser_id());
		maps.put("pwd", requestapi.getPwd());
		maps.put("dataFormat", requestapi.getData_format());
		maps.put("interfaceId", requestapi.getInterface_id());
		maps.put("dataCode",requestapi.getData_code());
		maps.put("times",querylog.getTimesStr());    //每次请求一个时间
		
		maps.put("staIds", requestapi.getSta_ids());
		List<String> list=WeatherDataUtil.strToArrayList(requestapi.getElements());
		maps.put("elements", list.get(0));  //至查询一个元素
		
		maps.put("limitCnt","1");  
		String httpUrl=requestapi.getUrl_pix();
		try {
			result = HttpClientUtil.getInstance().sendHttpPost(httpUrl, maps);
		} catch (Exception e) {
			e.printStackTrace();
		}
	    return result;
	}
	
	/**
	 * 请求 地面数据 
	 *  
	 *  时间范围查询 探查是否存在数据 根据返回码 code确认
	 * 
	 * @param result  结果
	 * @param 请求api表
	 * 
	 * */
	public static boolean isExistThreeData(String result,RequestApi requestapi){
		
		boolean flag=false;
		if(requestapi.getRequest_api_id().equals(RequestApiEnum.groundData.getValue())){
			GroundResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundResponseJson>() {
			});

			// 获取返回码
			String returnCode = jsonObject.getReturnCode();
			
			if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
				flag=true;
			}
			return flag;
		}else if(requestapi.getRequest_api_id().equals(RequestApiEnum.aerosolDataTask.getValue())){
			AerosolDataResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<AerosolDataResponseJson>() {
			});

			// 获取返回码
			String returnCode = jsonObject.getReturnCode();
			
			if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
				flag=true;
			}
			return flag;
		} else if(requestapi.getRequest_api_id().equals(RequestApiEnum.radiationTask.getValue())){
			RadiationResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<RadiationResponseJson>() {
			});

			// 获取返回码
			String returnCode = jsonObject.getReturnCode();
			
			if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
				flag=true;
			}
			return flag;
		}
		else if(requestapi.getRequest_api_id().equals(RequestApiEnum.radiationTask.getValue())){
			RadiationResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<RadiationResponseJson>() {
			});

			// 获取返回码
			String returnCode = jsonObject.getReturnCode();
			
			if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
				flag=true;
			}
			return flag;
		}
		else if(requestapi.getRequest_api_id().equals(RequestApiEnum.groundPre.getValue())){
			GroundPreResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundPreResponseJson>() {
			});

			// 获取返回码
			String returnCode = jsonObject.getReturnCode();
			
			if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
				flag=true;
			}
			return flag;
		}
		else if(requestapi.getRequest_api_id().equals(RequestApiEnum.groundTem.getValue())){
			GroundTemResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundTemResponseJson>() {
			});

			// 获取返回码
			String returnCode = jsonObject.getReturnCode();
			
			if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
				flag=true;
			}
			return flag;
		}
		else if(requestapi.getRequest_api_id().equals(RequestApiEnum.groundOther.getValue())){
			GroundOtherResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<GroundOtherResponseJson>() {
			});

			// 获取返回码
			String returnCode = jsonObject.getReturnCode();
			
			if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
				flag=true;
			}
			return flag;
		}
		else if(requestapi.getRequest_api_id().equals(RequestApiEnum.RadiationMin.getValue())){
			RadiationMinResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<RadiationMinResponseJson>() {
			});

			// 获取返回码
			String returnCode = jsonObject.getReturnCode();
			
			if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
				flag=true;
			}
			return flag;
		}else{
			return flag;
		}
		
	}
	
	
	/**
	 * 请求 高空
	 *  
	 *  时间范围查询 探查是否存在数据 根据返回码 code确认
	 * 
	 * @param result  结果
	 * 
	 * */
	public static boolean isExistHighData(String result){
		
		boolean flag=false;
		HighDataResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<HighDataResponseJson>() {
		});

		// 获取返回码
		String returnCode = jsonObject.getReturnCode();
		
		if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
			flag=true;
		}
		return flag;
	}
	
	/**
	 * 请求 高空
	 *  
	 *  时间范围查询 探查是否存在数据 根据返回码 code确认
	 * 
	 * @param result  结果
	 * 
	 * */
	public static boolean isExistRadiationMinData(String result){
		
		boolean flag=false;
		RadiationMinResponseJson jsonObject = JSONObject.parseObject(result, new TypeReference<RadiationMinResponseJson>() {
		});

		// 获取返回码
		String returnCode = jsonObject.getReturnCode();
		
		if(RequestApiCodeEnum.SUCCESS.getValue().equals(returnCode)){
			flag=true;
		}
		return flag;
	}
	
	/**
	 * 
	 * 探查 是否存在高空数据
	 * 
	 * 请求 高空定时值数据
	 *  
	 *  都可按 时间范围查询
	 * 
	 * @param RequestApi  提供 请求url 等其他固定参数
	 * @param QueryLog  提供  请求条件参数
	 * 
	 * */
	public static String getOneTimesData(RequestApi requestapi,QueryLog querylog){
		String result=new String();
		
		Map<String,String> maps=new HashMap<String,String>();
		maps.put("userId",requestapi.getUser_id());
		maps.put("pwd", requestapi.getPwd());
		maps.put("dataFormat", requestapi.getData_format());
		maps.put("interfaceId", requestapi.getInterface_id());
		maps.put("dataCode",requestapi.getData_code());
		maps.put("times",querylog.getTimesStr());    //每次请求一个时间
		maps.put("staIds", requestapi.getSta_ids());
		
		List<String> list=WeatherDataUtil.strToArrayList(requestapi.getElements());
		maps.put("elements", list.get(0));  //至查询一个元素
		maps.put("limitCnt","1"); 
		String httpUrl=requestapi.getUrl_pix();
		try {
			result = HttpClientUtil.getInstance().sendHttpPost(httpUrl, maps);
		} catch (Exception e) {
			e.printStackTrace();
		}
	    return result;
	}
	
	
	
	
	
	
	/**
	 * 
	 * 调用接口 工具类
	 * 
	 * 请求 高空定时值数据
	 *  
	 *  都可按 时间范围查询
	 * 
	 * @param RequestApi  提供 请求url 等其他固定参数
	 * @param QueryLog  提供  请求条件参数
	 * 
	 * */
	public static String requestTimesDataApi(RequestApi requestapi,QueryLog querylog){
		String result=new String();
		
		Map<String,String> maps=new HashMap<String,String>();
		maps.put("userId",requestapi.getUser_id());
		maps.put("pwd", requestapi.getPwd());
		maps.put("dataFormat", requestapi.getData_format());
		maps.put("interfaceId", requestapi.getInterface_id());
		maps.put("dataCode",requestapi.getData_code());
		maps.put("times",querylog.getTimesStr());    //每次请求一个时间
		maps.put("staIds", requestapi.getSta_ids());
		maps.put("elements", requestapi.getElements());
		//maps.put("limitCnt", String.valueOf(requestapi.getLimitCnt()));  返回全部数据
		String httpUrl=requestapi.getUrl_pix();
		try {
			result = HttpClientUtil.getInstance().sendHttpPost(httpUrl, maps);
		} catch (Exception e) {
			e.printStackTrace();
		}
	    return result;
	}
	
	
	
	/*public static String requestGroundDataOther(RequestApi requestApi){
		String result=new String();
		
		Map<String,String> maps=new HashMap<String,String>();
		maps.put("userId", "595337519805EYBzZ");
		maps.put("pwd", "BddpWWk");
		maps.put("dataFormat", "json");
		maps.put("interfaceId", "getSurfEleByTimeRangeAndStaID");
		maps.put("dataCode", "SURF_CHN_MUL_HOR");
		maps.put("timeRange", "[20200721000000,20200721230000]");
		maps.put("staIDs", "56778");
		maps.put("elements", "Day,Hour,PRS,PRS_Sea,PRS_Max,PRS_Min,TEM,TEM_Max,TEM_Min,RHU,RHU_Min,VAP,PRE_1h,WIN_D_INST_Max,WIN_D_S_Max,WIN_S_Avg_2mi,WIN_D_Avg_2mi,WEP_Now,WIN_S_Inst_Max,tigan,windpower,VIS,CLO_Cov,CLO_Cov_Low,CLO_COV_LM");
		String httpUrl="http://api.data.cma.cn:8090/api";
		try {
			result = HttpClientUtil.getInstance().sendHttpPost(httpUrl, maps);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	    return result;
	}
	*/
	/**
	 * 
	 * 计算下一个 时间间隔  日期
	 * @param increment  时间间隔
	 * @param startDate 开始时间
	 * 
	 * 
	 * 例如； 需要取一天的数据 
	 *     时间间隔参数 应为：2020 0721 00 00 00  至  2020 0721 23 00 00  
	 * 
	 *  开始日期为   2020 0721 00 00 00   (自行省略空格  2020年的 07月21号  0时 0分 0秒) 
	 * 
	 * 
	 * 
	 * */
	public static Date afterDate(Date startDate,int increment){
		
		Date resultTemp=WeatherDataUtil.calculateEndDate(startDate, increment);
		
		Calendar rightNow = Calendar.getInstance();
		rightNow.setTime(resultTemp);
		rightNow.add(Calendar.HOUR, -1);
		Date result=rightNow.getTime();      
		return result;
	}
	
	

	
	
	/**
	 * 
	 * 返回昨天的  23时00分00 秒 
	 * 
	 * */
    public static Date yesterday23(){
    	
    	String nowdateTemp=DataUtil.formatDate(new Date(),"yyyMMdd");
		String nowdateStr=nowdateTemp+"000000";
		System.out.println("nowdate:"+nowdateStr);
		
		//今天的时间
		Date nowdate= DateUtil.StringToDate(nowdateStr, "yyyyMMddHHmmss");
		
		System.out.println("今天的时间str："+DataUtil.formatDate(nowdate,"yyyyMMddHHmmss"));

		Date yesterday=WeatherDataUtil.calculateEndDate(nowdate, -1);
		
		System.out.println("昨天的时间str:"+DataUtil.formatDate(yesterday,"yyyyMMddHHmmss"));
		
		Date yesterday23=WeatherDataUtil.afterHour(yesterday, 23);
		
		System.out.println("昨天的时间23时str:"+DataUtil.formatDate(yesterday23,"yyyyMMddHHmmss"));
    	
		return yesterday23;
    }
    
	/**
	 * 
	 * 计算下一个 时间间隔  日期（对于分钟数据）
	 * @param increment  时间间隔
	 * @param startDate 开始时间
	 * 
	 * 
	 * 例如； 需要取一天的数据 
	 *     时间间隔参数 应为：2020 0721 00 00 00  至  2020 0721 23 59 00  
	 * 
	 *  开始日期为   2020 0721 00 00 00   (自行省略空格  2020年的 07月21号  0时 0分 0秒) 
	 * 
	 * 
	 * 
	 * */
	public static Date afterDateMin(Date startDate,int increment){
		
		Date resultTemp=WeatherDataUtil.calculateEndDate(startDate, increment);
		
		Calendar rightNow = Calendar.getInstance();
		rightNow.setTime(resultTemp);
		rightNow.add(Calendar.MINUTE, -1);
		Date result=rightNow.getTime();     
		System.out.println("下一个 时间间隔 str："+DataUtil.formatDate(result,"yyyyMMddHHmmss"));
		return result;
	}
	
	
    /**
	 * 
	 * 返回昨天的  00时00分00 秒 
	 * 
	 * */
    public static Date yesterday00(){
    	
    	String nowdateTemp=DataUtil.formatDate(new Date(),"yyyMMdd");
		String nowdateStr=nowdateTemp+"000000";
		System.out.println("nowdate:"+nowdateStr);
		
		//今天的时间
		Date nowdate= DateUtil.StringToDate(nowdateStr, "yyyyMMddHHmmss");
		
		System.out.println("今天的时间str："+DataUtil.formatDate(nowdate,"yyyyMMddHHmmss"));

		Date yesterday00=WeatherDataUtil.calculateEndDate(nowdate, -1);
		
		System.out.println("昨天的时间str:"+DataUtil.formatDate(yesterday00,"yyyyMMddHHmmss"));
		
		//Date yesterday23=WeatherDataUtil.afterHour(yesterday, 23);
		
		//System.out.println("昨天的时间23时str:"+DataUtil.formatDate(yesterday23,"yyyyMMddHHmmss"));
    	
		return yesterday00;
    }
    
	/**
	 * 
	 * 返回昨天的  23时59分00 秒 
	 * 
	 * */
    public static Date yesterday2359(){
    	
    	String nowdateTemp=DataUtil.formatDate(new Date(),"yyyMMdd");
		String nowdateStr=nowdateTemp+"000000";
		System.out.println("nowdate:"+nowdateStr);
		
		//今天的时间
		Date nowdate= DateUtil.StringToDate(nowdateStr, "yyyyMMddHHmmss");
		
		System.out.println("今天的时间0时0分str："+DataUtil.formatDate(nowdate,"yyyyMMddHHmmss"));

		
		Date yesterday2359=WeatherDataUtil.afterMin(nowdate, -1);
		
		System.out.println("昨天的时间23时59分str:"+DataUtil.formatDate(yesterday2359,"yyyyMMddHHmmss"));
    	
		return yesterday2359;
    }
    
	/**
	 * 
	 * 返回 传入日期的  昨天 的  23时00分00 秒 
	 * 例如传入  2020/8/16     返回  2020 / 8 /15 23:00:00
	 * 
	 * */
    public static Date dateToYesterday23(Date date){
    	
    	String nowdateTemp=DataUtil.formatDate(date,"yyyMMdd");
		String nowdateStr=nowdateTemp+"000000";
		System.out.println("nowdate:"+nowdateStr);
		
		//今天的时间
		Date nowdate= DateUtil.StringToDate(nowdateStr, "yyyyMMddHHmmss");
		
		System.out.println("今天的时间str："+DataUtil.formatDate(nowdate,"yyyyMMddHHmmss"));

		Date yesterday=WeatherDataUtil.calculateEndDate(nowdate, -1);
		
		System.out.println("昨天的时间str:"+DataUtil.formatDate(yesterday,"yyyyMMddHHmmss"));
		
		Date yesterday23=WeatherDataUtil.afterHour(yesterday, 23);
		
		System.out.println("昨天的时间23时str:"+DataUtil.formatDate(yesterday23,"yyyyMMddHHmmss"));
    	
		return yesterday23;
    }
    
	/**
	 * 
	 * 返回 传入日期的  昨天 的  23时59分00 秒 
	 * 例如传入  2020/8/16     返回  2020 / 8 /15 23:00:00
	 * 
	 * */
    public static Date dateToYesterday2359(Date date){
    	
    	String nowdateTemp=DataUtil.formatDate(date,"yyyMMdd");
		String nowdateStr=nowdateTemp+"000000";
		System.out.println("nowdate:"+nowdateStr);
		
		//今天的时间
		Date nowdate= DateUtil.StringToDate(nowdateStr, "yyyyMMddHHmmss");
		
		System.out.println("传入的时间00时00分str："+DataUtil.formatDate(nowdate,"yyyyMMddHHmmss"));

		// 减去1分钟后的日期
		Date yesterday2359=WeatherDataUtil.afterMin(nowdate, -1);
		
		System.out.println("昨天的时间23时59分str:"+DataUtil.formatDate(yesterday2359,"yyyyMMddHHmmss"));
    	
		return yesterday2359;
    }
	
	/**
	 * 
	 * 计算下一个  几个小时后的 时间
	 * @param increment  小时间隔   一个小时前 （-1）  一个小时后（1）
	 * @param startDate 开始时间
	 * 
	 * 
	 * 例如； 需要取一天的数据 
	 *     时间间隔参数 应为：2020 0721 00 00 00  至  2020 0721 23 00 00  
	 * 
	 *  开始日期为   2020 0721 00 00 00   (自行省略空格  2020年的 07月21号  0时 0分 0秒) 
	 * 
	 * 
	 * 
	 * */
	public static Date afterHour(Date startDate,int increment){
		
		
		Calendar rightNow = Calendar.getInstance();
		rightNow.setTime(startDate);
		rightNow.add(Calendar.HOUR, increment);
		Date result=rightNow.getTime();
		return result;
	}
	
	/**
	 * 
	 * 计算下一个  几个小时后的 时间
	 * @param increment  小时间隔   一个小时前 （-1）  一个小时后（1）
	 * @param startDate 开始时间
	 * 
	 * 
	 * 例如； 需要取一天的数据 
	 *     时间间隔参数 应为：2020 0721 00 00 00  至  2020 0721 23 00 00  
	 * 
	 *  开始日期为   2020 0721 00 00 00   (自行省略空格  2020年的 07月21号  0时 0分 0秒) 
	 * 
	 * 
	 * 
	 * */
	public static Timestamp afterHour(Timestamp startDate,int increment){
		
		Date start=new Date(startDate.getTime());
		Calendar rightNow = Calendar.getInstance();
		rightNow.setTime(start);
		rightNow.add(Calendar.HOUR, increment);
		Date result=rightNow.getTime();
		
		 Timestamp newTimestamp=new Timestamp(result.getTime());
		return newTimestamp;
	}

	/**
	 * 
	 * 计算下一个  几分钟  后的 时间
	 * @param increment  小时间隔   一分钟前 （-1） 一分钟后（1）
	 * @param startDate 开始时间
	 * 
	 * 
	 * 例如； 需要取一天的数据 
	 *     时间间隔参数 应为：2020 0721 00 00 00  至  2020 0721 23 59 00  
	 * 
	 *  开始日期为   2020 0721 00 00 00   (自行省略空格  2020年的 07月21号  0时 0分 0秒) 
	 * 
	 * 
	 * 
	 * */
	public static Date afterMin(Date startDate,int increment){
		
		
		Calendar rightNow = Calendar.getInstance();
		rightNow.setTime(startDate);
		rightNow.add(Calendar.MINUTE, increment);
		Date result=rightNow.getTime();
		return result;
	}
	
	
	/**
	 * 根据起始日期和间隔时间计算结束日期
	 * 
	 * @param sDate开始时间
	 * 
	 * @param days间隔时间
	 * 
	 * @return 结束时间
	 * */
	public static Date calculateEndDate(Date sDate, int days)
	{
		//将开始时间赋给日历实例
		Calendar sCalendar = Calendar.getInstance();
		sCalendar.setTime(sDate);
		//计算结束时间
		sCalendar.add(Calendar.DATE, days);
		//返回Date类型结束时间
		return sCalendar.getTime();
	}
	
	/**
	 * 根据起始日期和间隔时间计算结束日期
	 * 
	 * @param sDate开始时间
	 * 
	 * @param days间隔时间
	 * 
	 * @return 返回 Timestamp格式的时间
	 * */
	public static Timestamp calculateEndDate(Timestamp sDate, int days)
	{
		
		Date start=new Date(sDate.getTime());
		//将开始时间赋给日历实例
		Calendar sCalendar = Calendar.getInstance();
		sCalendar.setTime(start);
		//计算结束时间
		sCalendar.add(Calendar.DATE, days);
		//返回Date类型结束时间
	    Date newDate= sCalendar.getTime();
	    Timestamp newTimestamp=new Timestamp(newDate.getTime());
	    
	    return newTimestamp;
	}
	
	/**
	 * 
	 * 计算下一个  几分钟  后的 时间
	 * @param increment  小时间隔   一分钟前 （-1） 一分钟后（1）
	 * @param startDate 开始时间
	 * 
	 * 
	 * 例如； 需要取一天的数据 
	 *     时间间隔参数 应为：2020 0721 00 00 00  至  2020 0721 23 59 00  
	 * 
	 *  开始日期为   2020 0721 00 00 00   (自行省略空格  2020年的 07月21号  0时 0分 0秒) 
	 * 
	 * 
	 * 
	 * */
	public static Timestamp afterMin(Timestamp startDate,int increment){
		
		Date start=new Date(startDate.getTime());
		Calendar rightNow = Calendar.getInstance();
		rightNow.setTime(start);
		rightNow.add(Calendar.MINUTE, increment);
		Date result=rightNow.getTime();
		
		Timestamp newTimestamp=new Timestamp(result.getTime());
		return newTimestamp;
	}
	
    /**
     * 导出Excel(动态表头)
     * write时不传入class,table时传入并设置needHead为false
     * @return
     * @throws Exception 
     */
    public static  <T> boolean writeDynamicHeadExcel(List<ArrayList<Object>> listdata, File file, String sheetName, Class<GroundDataExcelDto> class1,List<List<String>> headList) {

    	if(!file.getParentFile().exists()){
			file.getParentFile().mkdirs();
		}
    	
    	
    	boolean flag=false;
        FileOutputStream fout;
		try {
			fout = new FileOutputStream(file);
			
			EasyExcel.write(fout) 
            .head(headList).registerConverter(new TimestampConverter())  //注册时间解析器
            .sheet(sheetName)
            .table().head(class1).needHead(Boolean.FALSE)
            .doWrite(listdata);
			
			return true;
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
        return flag;
        
    }
    
  
    /**
     * 导出Excel(一个sheet)
     *
     * @param response  HttpServletResponse
     * @param list      数据list
     * @param fileName  导出的文件名
     * @param sheetName 导入文件的sheet名
     * @param clazz 实体类
     * @throws FileNotFoundException 
     * @throws Exception 
     */
    public static <T> boolean  writeExcel(List<T> list, File file, String sheetName, Class<T> clazz) throws FileNotFoundException {

        //OutputStream outputStream = getOutputStream(response, fileName);
    	
    	if(!file.getParentFile().exists()){
			file.getParentFile().mkdirs();
		}

    	FileOutputStream fout = new FileOutputStream(file);
        ExcelWriter excelWriter = EasyExcel.write(fout, clazz).registerConverter(new TimestampConverter()).build();
        WriteSheet writeSheet = EasyExcel.writerSheet(sheetName).build();

        excelWriter.write(list, writeSheet);

        excelWriter.finish();
        return true;
    }
    
    /**
     * 
     * 	给HttpServletResponse设置响应头信息，表示返回的是一个文件流
     * 
     * */
    public static OutputStream getOutputStream(HttpServletResponse response,String fileName) throws Exception {
            fileName = URLEncoder.encode(fileName, "UTF-8");
            //不同的文件流类型有不同的contentType对照表,可自行百度
            response.setContentType("application/vnd.ms-excel");
            response.setCharacterEncoding("utf8");
            response.setHeader("Content-Disposition", "attachment; filename=" + fileName + ".xlsx");
            response.setHeader("Pragma", "public");
            return response.getOutputStream();
    }
    
    
    /**
     * 
     * 将 str格式（yyyy-MM-dd HH:mm:ss）的 日期 转为 timestamp格式的日期
     * */
    public static Timestamp strToTimestamp(String dateStr) throws ParseException{
		//return LocalDateTime.parse(cellData.getStringValue(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
		
		SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	    Date date;
		date = fmt.parse(dateStr);
		Timestamp newTimestamp=new Timestamp(date.getTime());
		
		return newTimestamp;
    }
    
    
    /**
     * 
     * 字符串分割 返回集合
     * */
    public static List<String> strToArrayList(String str){
    	List<String> ar=new ArrayList<String>();
    	String[] strs=str.split(",");
    	int strsl=strs.length;
    	if(strsl>0){
    		ar= Arrays.asList(str.split(","));
    		return ar;
    		
    	}else{
    		return null;
    	}
    }
    
    /**
     * 
     * 字符串分割 返回集合
     * @param str 字符串
     * @param str 分割字符串
     * */
    public static List<String> strToArrayList(String str,String split){
    	List<String> ar=new ArrayList<String>();
    	String[] strs=str.split(split);
    	int strsl=strs.length;
    	if(strsl>0){
    		ar= Arrays.asList(str.split(split));
    		return ar;
    		
    	}else{
    		return null;
    	}
    }
    
    /**
     * 计算特殊格式的日期的间隔天数
     * 
     * @param startTime  格式   yyyyMMdd000000
     * @param endTime   格式  yyyyMMdd23000000
     * 
     * 例如      20200816000000 与 20200816230000  间隔一天 
     * */
    public static int dateiItervalDays(Date startTime,Date endTime){
    	
    	
    	String dbtime1 =DataUtil.formatDate(startTime,"yyyyMMdd");  //第二个日期
		String dbtime2 =DataUtil.formatDate(endTime,"yyyyMMdd");//第一个日期
    	//算两个日期间隔多少天
    	SimpleDateFormat format = new SimpleDateFormat("yyyyMMdd");
    	Date date1;
    	Date date2;
    	
		try {
			date1 = format.parse(dbtime1);
		    date2 = format.parse(dbtime2);
		    int a = (int) ((date2.getTime() - date1.getTime()) / (1000*3600*24))+1;
	    	return a;
		} catch (ParseException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
    	return 0;
    }
    
    /**
     * 
     * 例如： 20200801000000 ---20200816230000  如果   0811这天 是 最新的有数据时间点  则返回 2020081123000000 时间
     * 传入 时间端  返回 有数据的最新 时间末尾    <br/>
     * [0801,0802,0803,0804,0805]  <br/>
     * [true,fslse,true,false,false]  <br/>  返回到 2020080323000000
     *
     * */
    public static Date getLastEndTime(Date startTime,Date endTime,RequestApi requestapi){
    	
    	List<Date> listDate=new ArrayList<Date>();
    	boolean [] flag=new boolean[50];
    	listDate.add(startTime);
    	int jiange=WeatherDataUtil.dateiItervalDays(startTime, endTime);
    	
    	for(int i=1;i<jiange;i++){
    		Date nextStartDate=WeatherDataUtil.calculateEndDate(startTime, 1);
    		listDate.add(nextStartDate);
    		startTime=nextStartDate;
    	}
    	
    	Iterator<Date>  iter=listDate.iterator();
    	int i=0;
    	while(iter.hasNext()){
    		Date start=iter.next();
    		Date end=WeatherDataUtil.afterHour(start,23);
    		
    		System.out.println("start："+DataUtil.formatDate(start,"yyyyMMddHHmmss"));
    		System.out.println("end："+DataUtil.formatDate(end,"yyyyMMddHHmmss"));
    		
    		QueryLog newql=new QueryLog();
			//查询时间
			newql.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(start, end));
			
			String result=WeatherDataUtil.getThereRequestOneData(requestapi, newql);
			boolean isexist=false;
			if(result !=null){
				isexist=WeatherDataUtil.isExistThreeData(result, requestapi);
			}else{ //如果上次 探查 请求数据超时   则在探查一次
				result=WeatherDataUtil.getThereRequestOneData(requestapi, newql);
				if(result !=null){
					isexist=WeatherDataUtil.isExistThreeData(result, requestapi);
				}
			}
			flag[i]=isexist;
			i++;
			
    	}
    	
    	int resultIndex=0;
    	
    	for(int j=flag.length-1;j>=0;j--){
    		if(flag[j]){
    			resultIndex=j;
    			break;
    		}
    	}
    	
    	if(listDate.get(resultIndex) !=null){
    		Date rt=WeatherDataUtil.afterHour(listDate.get(resultIndex),23);
    		return rt;
    	}
    	
    	return null;
    	
    }
    
    
    /**
     * 
     * 例如： 20200801000000 ---20200816230000  如果   0811这天 是 最新的有数据时间点  则返回 2020081123000000 时间
     * 传入 时间端  返回 有数据的最新 时间末尾    <br/>
     * [0801,0802,0803,0804,0805]  <br/>
     * [true,fslse,true,false,false]  <br/>  返回到 2020080323000000
     *
     * */
    public static Date getLastEndTimeMinData(Date startTime,Date endTime,RequestApi requestapi){
    	
    	List<Date> listDate=new ArrayList<Date>();
    	boolean [] flag=new boolean[50];
    	listDate.add(startTime);
    	int jiange=WeatherDataUtil.dateiItervalDays(startTime, endTime);
    	
    	for(int i=1;i<jiange;i++){
    		Date nextStartDate=WeatherDataUtil.calculateEndDate(startTime, 1);
    		listDate.add(nextStartDate);
    		startTime=nextStartDate;
    	}
    	
    	Iterator<Date>  iter=listDate.iterator();
    	int i=0;
    	while(iter.hasNext()){
    		Date start=iter.next();
    		
    		//start时间的  23时59分00秒时间
    		Date end=WeatherDataUtil.afterHour(WeatherDataUtil.calculateEndDate(start, 1),-1);
    		
    		System.out.println("start："+DataUtil.formatDate(start,"yyyyMMddHHmmss"));
    		System.out.println("end："+DataUtil.formatDate(end,"yyyyMMddHHmmss"));
    		
    		QueryLog newql=new QueryLog();
			//查询时间
			newql.setTimeRangeStr(WeatherDataUtil.getTimerangeStr(start, end));
			
			String result=WeatherDataUtil.getThereRequestOneData(requestapi, newql);
			boolean isexist=false;
			if(result !=null){
				isexist=WeatherDataUtil.isExistThreeData(result, requestapi);
			}else{ //如果上次 探查 请求数据超时   则在探查一次
				result=WeatherDataUtil.getThereRequestOneData(requestapi, newql);
				if(result !=null){
					isexist=WeatherDataUtil.isExistThreeData(result, requestapi);
				}
			}
			flag[i]=isexist;
			i++;
			
    	}
    	
    	int resultIndex=0;
    	
    	for(int j=flag.length-1;j>=0;j--){
    		if(flag[j]){
    			resultIndex=j;
    			break;
    		}
    	}
    	
    	if(listDate.get(resultIndex) !=null){
    		Date rt=WeatherDataUtil.afterHour(listDate.get(resultIndex),23);
    		return rt;
    	}
    	
    	return null;
    	
    }
    
    
    /**
     * 
     * 例如： 20200801000000 ---20200816230000  如果   0811这天 是 最新的有数据时间点  则返回 2020081100000000 时间
     * 传入 时间端  返回 有数据的最新 时间末尾    <br/>
     * [0801,0802,0803,0804,0805]  <br/>
     * [true,fslse,true,false,false]  <br/>  返回到 2020080300000000
     *
     * */
    public static Date getLastEndTimeHighData(Date startTime,Date endTime,RequestApi requestapi){
    	
    	List<Date> listDate=new ArrayList<Date>();
    	boolean [] flag=new boolean[50];
    	
    	listDate.add(startTime);
    	
    	int jiange=WeatherDataUtil.dateiItervalDays(startTime, endTime);
    	
    	for(int i=1;i<jiange;i++){
    		//一天后的时间点 
    		Date nextStartDate=WeatherDataUtil.calculateEndDate(startTime, 1);
    		listDate.add(nextStartDate);
    		startTime=nextStartDate;
    	}
    	
    	Iterator<Date>  iter=listDate.iterator();
    	int i=0;
    	while(iter.hasNext()){
    		Date start=iter.next();
    		//一天后的时间点 
    		Date end=WeatherDataUtil.calculateEndDate(start, 1);
    		
    		System.out.println("start："+DataUtil.formatDate(start,"yyyyMMddHHmmss"));
    		System.out.println("end："+DataUtil.formatDate(end,"yyyyMMddHHmmss"));
    		
    		QueryLog querylog=new QueryLog();
			//查询时间
    		
    		querylog.setTimesStr(DataUtil.formatDate(end,"yyyyMMddHHmmss"));
			
			String result=WeatherDataUtil.getOneTimesData(requestapi, querylog);
			boolean isexist=false;
			if(result !=null){
				isexist=WeatherDataUtil.isExistHighData(result);
			}else{ //如果上次 探查 请求数据超时   则在探查一次
				result=WeatherDataUtil.getOneTimesData(requestapi, querylog);
				if(result !=null){
					isexist=WeatherDataUtil.isExistHighData(result);
				}
			}
			flag[i]=isexist;
			i++;
			
    	}
    	
    	int resultIndex=0;
    	
    	for(int j=flag.length-1;j>=0;j--){
    		if(flag[j]){
    			resultIndex=j;
    			break;
    		}
    	}
    	
    	if(listDate.get(resultIndex) !=null){
    		Date rt=listDate.get(resultIndex);
    		return rt;
    	}
    	
    	return null;
    	
    }
    
    
    /**
     * 
     * 例如： 20200801000000 ---20200816230000  如果   0811这天 是 最新的有数据时间点  则返回 2020081100000000 时间
     * 传入 时间端  返回 有数据的最新 时间末尾    <br/>
     * [0801,0802,0803,0804,0805]  <br/>
     * [true,fslse,true,false,false]  <br/>  返回到 2020080300000000
     *
     * */
    public static Date getLastEndTimeRadiationData(Date startTime,Date endTime,RequestApi requestapi){
    	
    	List<Date> listDate=new ArrayList<Date>();
    	boolean [] flag=new boolean[50];
    	
    	listDate.add(startTime);
    	
    	int jiange=WeatherDataUtil.dateiItervalDays(startTime, endTime);
    	
    	for(int i=1;i<jiange;i++){
    		//一天后的时间点 
    		Date nextStartDate=WeatherDataUtil.calculateEndDate(startTime, 1);
    		listDate.add(nextStartDate);
    		startTime=nextStartDate;
    	}
    	
    	Iterator<Date>  iter=listDate.iterator();
    	int i=0;
    	while(iter.hasNext()){
    		Date start=iter.next();
    		//一天后的时间点 
    		Date end=WeatherDataUtil.calculateEndDate(start, 1);
    		
    		System.out.println("start："+DataUtil.formatDate(start,"yyyyMMddHHmmss"));
    		System.out.println("end："+DataUtil.formatDate(end,"yyyyMMddHHmmss"));
    		
    		QueryLog querylog=new QueryLog();
			//查询时间
    		
    		querylog.setTimesStr(DataUtil.formatDate(end,"yyyyMMddHHmmss"));
			
			String result=WeatherDataUtil.getOneTimesData(requestapi, querylog);
			boolean isexist=false;
			if(result !=null){
				isexist=WeatherDataUtil.isExistRadiationMinData(result);
			}else{ //如果上次 探查 请求数据超时   则在探查一次
				result=WeatherDataUtil.getOneTimesData(requestapi, querylog);
				if(result !=null){
					isexist=WeatherDataUtil.isExistRadiationMinData(result);
				}
			}
			flag[i]=isexist;
			i++;
			
    	}
    	
    	int resultIndex=0;
    	
    	for(int j=flag.length-1;j>=0;j--){
    		if(flag[j]){
    			resultIndex=j;
    			break;
    		}
    	}
    	
    	if(listDate.get(resultIndex) !=null){
    		Date rt=listDate.get(resultIndex);
    		return rt;
    	}
    	
    	return null;
    	
    }
    
    
    /**
     * 
     * 传入 Date 格式的日期    返回年  月 日字符串  格式 yyyy  M  d
     * @param Date date
     * @return Map<String,String>  <br>
     *  key:   year  mon day <br>
     *  value:  2020  8  1
     *
     * */
    public  static Map<String,String> getYearMonDayStr(Date date){
    	
    	
    	//Date dateTemp=date;
    	Date dateStart=date;
        String year=DateUtil.DateToString(dateStart, "yyyy");
        String mon=DateUtil.DateToString(dateStart, "M");
        String day=DateUtil.DateToString(dateStart, "d");
    	System.out.println(year+"  "+mon+" "+day);
    	Map<String,String> map=new HashMap<String,String>();
    	map.put("year", year);
    	map.put("mon",mon);
    	map.put("day", day);
    	
    	return map;
    }
    
    /**
     * 返回   月份的字符串
     * */
    public static String getMonMMStr(int mon){
    	String monStr="";
    	if(mon>0 && mon<10){
    		 monStr="0"+String.valueOf(mon);
    		return monStr;
    	}else if(mon >9 && mon <13){
    		monStr=String.valueOf(mon);
    		return monStr;
    	}else{
    		return null;
    	}
    	
    }
    
    /**
     * 删除目录下的文件 返回删除文件个数
     * 
     * */
    public static int deleteFile(File filePath) throws Exception{
		File file=filePath;
		if(file.exists()){
		int deleteSumFile=FileUtil.deleteFolder(file);
		return deleteSumFile;
			
		}else{
			throw new WeatherException(ResultCodeEnum.ERROR_9007);
		}
	}
    
    
    public static String getTimesStr(List<String> list){
    	String str="";
    	if(list.size()>0){
    		Iterator<String> iter=list.iterator();
    		while(iter.hasNext()){
    			String timeStr=iter.next();
    			str=str+timeStr+",";
    		}
    		str=str.substring(0,str.length()-1);
    		return str;
    	}
    	return str;
    }

    
}
